vlwkaos' digital garden

Rust - reference

returning a ref


fn return_it() -> &String {
    let country = String::from("일본");
    &country // return &String
    // 이건 불가능함 왜냐면 borrowed type이라서, 
    // 함수 나가면서 country가 폐기됨, 그럼 뭘 참조하는지 알 수 없음
}


fn main() {
    let country = String::from("한국");
    let ref_one = &country; // 볼수만 있다
    let ref_two = &country;

    println!("Country: {}", ref_one);

    // 아래는 에러
    // returned type contains borrowed type
    let my_coutnry = return_it(); 
}

mutable ref

// & immutable referenfce / shared reference
// &mut mutable reference / unique reference

fn main() {
    let mut num = 9;
    let numref = &mut num; 
    numref = 10; // 이건 불가능, 
    *numref = 10; // 이렇게 deference 
    println!("num: {}", num); // 10

    num = 10; // 이러면 에러? 이미 참조를 빌려갔다
    let anotherref = &mut num; //이것도 에러 두번 빌릴 수 없다.
    let anoanotherref = numref; // 이렇게는 가능하다. 여기로 reference가 넘어간다.
    // 이렇듯 mutable reference는 non-copy 타입이다.
}

https://cotigao.medium.com/mutable-reference-in-rust-995320366e22

rust compiler is always angry at shared mutability / dangling references

references and shadowing

immutable, mutable같이 쓰면 컴파일러가 화낸다. 위에 같은

함수에서

fn print_country(c: String) {
    println!("asdf {}", c);
}

fn print_country_ref(c: &String) {
    println!("asdf {}", c);
}

fn main() {
    let country = "하아".to_string();
    print_country(country); // 여기서 println이 c의 소유권이 넘어가버림 
    //여기서 반환을 해주거나 해야함, 근데 이상함 매번 리턴해?
    // 그래서 함수에서 ref를 받는거임
    print_country_ref(&country); // function is borrowing ref

}

mutable ref in func

fn add(c: &mut String) {
    c.push_str("gkgk");
    println!("now: {}", c);
}

// take by value, declare as mutable
// 값을 가져와서 mutable로 새로? reference랑 상관없음
fn mutadd(mut c: String) {
    c.push_str("ahahs");
    println!("asdf: {}", c);
}


fn main() {
    let mut c = "asdf".to_string();
    add(&mut c);

    let immuta = "asdf".to_string();
    mutadd(immuta);
}

note

unsafe, static
str heap 구조
메모리 관리가 컴파일 이전에 최대한 타이트하게 발생
- immutable ref를 선언한 경우 아래에서 mutable ref선언할 수 없다.
  - immutable ref를 이미 선언했으니까 얘의 불변성을 컴파일전에 보장해줘야하기 때문

Deferencing and the dot operator

struct Item {
    number: u8
}

impl Item {
    fn compare_number(&self, other_num: u8) {
        println!("{}", self.number == other_num);
    }
}


fn main() {
    let my_number = 10;
    let reference = &my_number;

    let item = Item {
        number: 10  
    };

    let ref = &item.number; // &u8 숫자의 그건 없음
    let refitem = &item;
    refitem.compare_number(10); // true

    // && 이어도 .을 쓰면 dereference가 된다.
    let refref = &refitem;
    refref.compare_number(10);
    
}

왜 만들어진 기능?
- C에서 처럼 deref/ref 신경쓰는거 좀 어려웠기 때문에 이런 기능을 탑재함

Referred in

Rust

Rust - reference